home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 5 / Gekikoh Dennoh Club Vol. 5 (Japan) (Track 01).bin / internet / tcppack / tcppackb.lzh / src / libether / libether.c
Encoding:
C/C++ Source or Header  |  1995-11-07  |  8.3 KB  |  419 lines
  1. /*
  2.  * libether.a - C library for Etherdrv API.
  3.  *
  4.  * Copyright (C) 1994 First Class Technology.
  5.  */
  6.  
  7. #include<stddef.h>
  8. #include<string.h>
  9. #include"etherdrv.h"
  10.  
  11. #include<stddef.h>
  12. #include<string.h>
  13. #define __DOS_INLINE__
  14. #include<sys/dos.h>
  15. #include"etherdrv.h"
  16.  
  17. #define DEV_NAME_LEN (8)
  18. #define MAX_DEVICE (8)
  19.  
  20. typedef struct dev_link
  21. {
  22.   struct dev_link *next;
  23.   unsigned short attribute;
  24.   void *str;
  25.   void *intr;
  26.   unsigned char dev_name[DEV_NAME_LEN];
  27. } dev_link;
  28.  
  29. typedef struct dev_stat
  30. {
  31.   unsigned char name[DEV_NAME_LEN];
  32.   int trap_no;
  33.   etd_func func;
  34. } dev_stat;
  35.  
  36. static dev_stat func[MAX_DEVICE];
  37.  
  38. static int search_etd_entry (char *);
  39. static etd_func search_etd_entry_sub (char *);
  40. static long _etd_entry (etd_cmd, void *, int);
  41. static long _etd_entry2 (etd_cmd, void *, int);
  42.  
  43. /************************************************
  44.  *                        *
  45.  ************************************************/
  46. long
  47. ETDGetDriverVersion (char *dev_name, int *ino)
  48. {
  49.   *ino = search_etd_entry (dev_name);
  50.  
  51.   if (*ino < 0)
  52.     return *ino;
  53.   return _etd_entry (etd_get_driver_version, NULL, *ino);
  54. }
  55.  
  56. /************************************************
  57.  *                        *
  58.  ************************************************/
  59. eaddr *
  60. ETDGetMacAddr (eaddr *dst, int ino)
  61. {
  62.   return (eaddr *)_etd_entry (etd_get_mac_addr, dst, ino);
  63. }
  64.  
  65. /************************************************
  66.  *                        *
  67.  ************************************************/
  68. eaddr *
  69. ETDGetPromAddr (eaddr *dst, int ino)
  70. {
  71.   return (eaddr *)_etd_entry (etd_get_prom_addr, dst, ino);
  72. }
  73.  
  74. /************************************************
  75.  *                        *
  76.  ************************************************/
  77. int
  78. ETDSetMacAddr (eaddr *dst, int ino)
  79. {
  80.   return _etd_entry (etd_set_mac_addr, dst, ino);
  81. }
  82.  
  83. /************************************************
  84.  *                        *
  85.  ************************************************/
  86. int
  87. ETDSendPacket (int size, void *packet, int ino)
  88. {
  89.   long args[2];
  90.  
  91.   args[0] = size;
  92.   args[1] = (long)packet;
  93.   return _etd_entry (etd_send_ether_packet, args, ino);
  94. }
  95.  
  96. /************************************************
  97.  *                        *
  98.  ************************************************/
  99. int
  100. ETDSetIntAddr (unsigned long prt, void *_func, int ino)
  101. {
  102.   long args[2];
  103.  
  104.   args[0] = prt;
  105.   args[1] = (long)_func;
  106.  
  107.   return _etd_entry (etd_set_int_addr, args, ino);
  108. }
  109.  
  110. /************************************************
  111.  *                        *
  112.  ************************************************/
  113. void *
  114. ETDGetIntAddr (unsigned long prt, int ino)
  115. {
  116.   return (void *)_etd_entry (etd_get_int_addr, (long*)prt, ino);
  117. }
  118.  
  119. /************************************************
  120.  *                        *
  121.  ************************************************/
  122. int
  123. ETDDelIntAddr (unsigned long prt, int ino)
  124. {
  125.   return _etd_entry (etd_del_int_addr, (long *)prt, ino);
  126. }
  127.  
  128. /************************************************
  129.  *                        *
  130.  ************************************************/
  131. int
  132. ETDSetMulticastAddr (char *p, int ino)
  133. {
  134.   return _etd_entry (etd_set_multicast_addr, (long *)p, ino);
  135. }
  136.  
  137. /************************************************
  138.  *                        *
  139.  ************************************************/
  140. int
  141. ETDGetStatistics (char *p, int ino)
  142. {
  143.   return _etd_entry (etd_get_statistics, (long *)p, ino);
  144. }
  145.  
  146. /************************************************
  147.  *                        *
  148.  ************************************************/
  149. static int
  150. search_etd_entry (char *dev_name)
  151. {
  152.   long ssp;
  153.   etd_func _func;
  154.   int i;
  155.  
  156.   _func = NULL;
  157.   for (i = 0; i < MAX_DEVICE; i++)
  158.     {
  159.       if (*func[i].name && !memcmp (func[i].name, dev_name, DEV_NAME_LEN))
  160.     {
  161.       _func = func[i].func;
  162.       break;
  163.     }
  164.       else if (!func[i].func)
  165.     break;
  166.     }
  167.  
  168.   if (!_func)
  169.     {
  170.       /* Did I find any space to store? */
  171.       if (i < MAX_DEVICE)
  172.     {
  173.       ssp = _dos_super (0);
  174.       _func = search_etd_entry_sub (dev_name);
  175.       if (ssp > 0)
  176.         _dos_super (ssp);
  177.  
  178.       if (_func)
  179.         {
  180.           memcpy (func[i].name, dev_name, DEV_NAME_LEN);
  181.           func[i].func = _func;
  182.           func[i].trap_no = -1;
  183.           func[i].trap_no = _etd_entry (-1, NULL, i);
  184.           return i;
  185.         }
  186.       else
  187.         return -1;
  188.     }
  189.       else
  190.     return -1;
  191.     }
  192.   else
  193.     return i;
  194. }
  195.  
  196. /************************************************
  197.  *                        *
  198.  ************************************************/
  199. static etd_func
  200. search_etd_entry_sub (char *dev_name)
  201. {
  202.   unsigned short *p;
  203.   int found;
  204.   dev_link *cur;
  205.  
  206.   /* search NUL */
  207.   found = 0;
  208.   for (p = (unsigned short *)0x6800; p < (unsigned short *)0x68000; p++)
  209.     {
  210.       if (*p == 'NU' && *(p + 1) == 'L ' && *(p + 2) == '  ' && *(p + 3) == '  ')
  211.     {
  212.       found = 1;
  213.       break;
  214.     }
  215.     }
  216.  
  217.   if (!found)
  218.     return NULL;
  219.  
  220.   /* device link é≡ ÆHéΘ */
  221.   found = 0;
  222.   cur = (dev_link *)((char *)p - offsetof (dev_link, dev_name));
  223.   for (; cur != (dev_link *)0xffffffff; cur = cur->next)
  224.     {
  225.       if (!memcmp (cur->dev_name, dev_name, DEV_NAME_LEN)
  226.       && !memcmp ((char *)cur + sizeof (dev_link), "EthD", 4))
  227.     {
  228.       found = 1;
  229.       break;
  230.     }
  231.     }
  232.  
  233.   if (!found)
  234.     return NULL;
  235.  
  236.   return (etd_func)((char *)cur + sizeof (dev_link) + 8);
  237. }
  238.  
  239. /************************************************
  240.  *                        *
  241.  ************************************************/
  242. static long
  243. _etd_entry (etd_cmd cmd, void *args, int ino)
  244. {
  245.   register long result asm ("d0");
  246.   register etd_func _func asm ("a1");
  247.   int i;
  248.  
  249.   if ((i = func[ino].trap_no) >= 0)
  250.     return _etd_entry2 (cmd, args, i);
  251.  
  252.   _func = func[ino].func;
  253.   asm volatile ("move.l\t%2,a0\n"
  254.         "\tmove.l\t%1,d0\n"
  255.         "\tmove.l\t%3,-(sp)\n"
  256.         "\tDOS\tSUPER_JSR\n"
  257.         "\taddq.l\t#4,sp"
  258.         : "d=" (result)
  259.         : "g" (cmd), "g" (args), "g" (_func)
  260.         : "d0", "a0");
  261.  
  262.   return result;
  263. }
  264.  
  265. /*
  266. **
  267. */
  268. static long
  269. trap_0 (etd_cmd cmd, void *arg)
  270. {
  271.   register long result asm ("d0");
  272.  
  273.   asm volatile ("move.l\t%2,a0\n"
  274.         "\tmove.l\t%1,d0\n"
  275.         "\ttrap\t#0\n"
  276.         : "d=" (result)
  277.         : "g" (cmd), "g" (arg)
  278.         : "d0", "d1", "d2", "a0", "a1", "a2");
  279.  
  280.   return result;
  281. }
  282. /*
  283. **
  284. */
  285. static long
  286. trap_1 (etd_cmd cmd, void *arg)
  287. {
  288.   register long result asm ("d0");
  289.  
  290.   asm volatile ("move.l\t%2,a0\n"
  291.         "\tmove.l\t%1,d0\n"
  292.         "\ttrap\t#1\n"
  293.         : "d=" (result)
  294.         : "g" (cmd), "g" (arg)
  295.         : "d0", "d1", "d2", "a0", "a1", "a2");
  296.  
  297.   return result;
  298. }
  299. /*
  300. **
  301. */
  302. static long
  303. trap_2 (etd_cmd cmd, void *arg)
  304. {
  305.   register long result asm ("d0");
  306.  
  307.   asm volatile ("move.l\t%2,a0\n"
  308.         "\tmove.l\t%1,d0\n"
  309.         "\ttrap\t#2\n"
  310.         : "d=" (result)
  311.         : "g" (cmd), "g" (arg)
  312.         : "d0", "d1", "d2", "a0", "a1", "a2");
  313.  
  314.   return result;
  315. }
  316. /*
  317. **
  318. */
  319. static long
  320. trap_3 (etd_cmd cmd, void *arg)
  321. {
  322.   register long result asm ("d0");
  323.  
  324.   asm volatile ("move.l\t%2,a0\n"
  325.         "\tmove.l\t%1,d0\n"
  326.         "\ttrap\t#3\n"
  327.         : "d=" (result)
  328.         : "g" (cmd), "g" (arg)
  329.         : "d0", "d1", "d2", "a0", "a1", "a2");
  330.  
  331.   return result;
  332. }
  333. /*
  334. **
  335. */
  336. static long
  337. trap_4 (etd_cmd cmd, void *arg)
  338. {
  339.   register long result asm ("d0");
  340.  
  341.   asm volatile ("move.l\t%2,a0\n"
  342.         "\tmove.l\t%1,d0\n"
  343.         "\ttrap\t#4\n"
  344.         : "d=" (result)
  345.         : "g" (cmd), "g" (arg)
  346.         : "d0", "d1", "d2", "a0", "a1", "a2");
  347.  
  348.   return result;
  349. }
  350. /*
  351. **
  352. */
  353. static long
  354. trap_5 (etd_cmd cmd, void *arg)
  355. {
  356.   register long result asm ("d0");
  357.  
  358.   asm volatile ("move.l\t%2,a0\n"
  359.         "\tmove.l\t%1,d0\n"
  360.         "\ttrap\t#5\n"
  361.         : "d=" (result)
  362.         : "g" (cmd), "g" (arg)
  363.         : "d0", "d1", "d2", "a0", "a1", "a2");
  364.  
  365.   return result;
  366. }
  367. /*
  368. **
  369. */
  370. static long
  371. trap_6 (etd_cmd cmd, void *arg)
  372. {
  373.   register long result asm ("d0");
  374.  
  375.   asm volatile ("move.l\t%2,a0\n"
  376.         "\tmove.l\t%1,d0\n"
  377.         "\ttrap\t#6\n"
  378.         : "d=" (result)
  379.         : "g" (cmd), "g" (arg)
  380.         : "d0", "d1", "d2", "a0", "a1", "a2");
  381.  
  382.   return result;
  383. }
  384. /*
  385. **
  386. */
  387. static long
  388. trap_7 (etd_cmd cmd, void *arg)
  389. {
  390.   register long result asm ("d0");
  391.  
  392.   asm volatile ("move.l\t%2,a0\n"
  393.         "\tmove.l\t%1,d0\n"
  394.         "\ttrap\t#7\n"
  395.         : "d=" (result)
  396.         : "g" (cmd), "g" (arg)
  397.         : "d0", "d1", "d2", "a0", "a1", "a2");
  398.  
  399.   return result;
  400. }
  401.  
  402. static long (*trap_entry[8]) (etd_cmd, void *) =
  403. {
  404.   trap_0, trap_1, trap_2, trap_3,
  405.   trap_4, trap_5, trap_6, trap_7,
  406. };
  407.  
  408. /************************************************
  409.  *                        *
  410.  ************************************************/
  411. static long
  412. _etd_entry2 (etd_cmd cmd, void *args, int i)
  413. {
  414.   if (i < 0 || i > 7)
  415.     return -1;
  416.  
  417.   return trap_entry[i] (cmd, args);
  418. }
  419.